This PR adds the asynchronous complements Database and Statement to the node:sqlite module.

Given that a single sqlite db connection cannot scale beyond a single CPU core, (unlike the old sqlite3) this implementation avoids unordered dispatches to the thread pool by maintaining a strict FIFO operation queue. This allows usage of multiple db connections in parallel without relying on the internal db connection mutex (=> SQLITE_THREADSAFE=2 is sufficient). Furthermore I've favored throughput over latency, e.g. it collects asynchronous operations on a db connection and dispatches them in batches to the thread pool. This helps to amortize the inherent synchronization overhead over multiple operations and it also improves cache locality.

The implementation effort has reached a maturity level where the overall approach should only require relatively small incremental changes to reach the outlined API scope. Briefly the following things work:

• Opening a db connection and (asynchronously) preparing statements.
• Disposal of db connection and statement instances.¹
• Database.prototype.exec() without a prepared statement.
• Statement.prototype.get()|all()|run() with binding parameters (though currently not as fancy as the sync variant).
• Implicit microtask-based batching of all previously mentioned operations (inspired by kysely).

Things which still need work:

• Function parameter validation should not throw but return rejected promises.
• Implementing the remaining APIs:
  • Database#location(dbName?: string): Promise<string|null>
  • Database#loadExtension(path: string): Promise<void>;
  • Database#enableLoadExtension(allow: boolean): Promise<void>
  • Database#enableDefensive(active: boolean): Promise<void>
• The memory allocation strategy should be tweaked to use std::pmr::monotonic_buffer_resource in a few places.
• Probably a few extensions to the test suite here and there.
• Proper API documentation
• From a brief look it seems that direct usage of v8::Promise looses the async context/callstack. I need some guidance on how to fix that.
• An explicit batching API, either callback- or Symbol.dispose/using-based (different PR?)
• Explore an API to move a db connection from Database to DatabaseSync and vice versa (different PR?)

Fixes #54307
Previous attempt #59109 (I've only taken the test suites from there).

API synopsis

interface StatementOptions {
    readBigInts?: boolean;
    returnArrays?: boolean;
    // NOT GOING TO BE IMPLEMENTED HERE:
    // allowBareNamedParameters
    // allowUnknownNamedParameters
}
interface DatabaseOpenOptions extends StatementOptions {
    open?: boolean;
    readOnly?: boolean;
    enableForeignKeyConstraints?: boolean;
    enableDoubleQuotedStringLiterals?: boolean;
    allowExtension?: boolean;
    timeout?: number;
    defensive?: boolean;
    limits?: object;
}
interface DatabaseCtor {
    new(path: string, options?: DatabaseOpenOptions): Database;
}
interface Database {
    open(): void;
    isOpen: boolean;
    close(): Promise<void>;
    [Symbol.asyncDispose](): Promise<void>;

    location(dbName?: string): Promise<string|null>;
    loadExtension(path: string): Promise<void>; // TODO
    enableLoadExtension(allow: boolean): Promise<void>; // TODO
    enableDefensive(active: boolean): Promise<void>; // TODO

    isInTransaction(): Promise<boolean>;

    exec(sql: string): Promise<void>;
    prepare(sql: string, options?: StatementOptions): Promise<Statement>;
}

type Literal = null | number | bigint | string | ArrayBufferView;
type BindParams = Record<string, Literal> | Array<Literal>;
type RowResult = Record<string, Literal> | Array<Literal>;
interface Statement {
    [Symbol.dispose](): void;

    get(params?: BindParams): Promise<RowResult | undefined>;
    all(params?: BindParams): Promise<RowResult[]>;
    run(params?: BindParams): Promise<{ changes: number, lastInsertRowid: number }>;
}